import Interceptor from './core/interceptor';
import Request from './index';
import store from '../../store';

export const globalInterceptor = {
	request: new Interceptor(),
	response: new Interceptor()
};
let systemInfo = uni.getSystemInfoSync()
let {
	DeviceBrand,
	DeviceModel
} = {
	// #ifndef H5
	DeviceBrand: systemInfo.brand,
	// #endif
	// #ifdef H5
	DeviceBrand: '',
	// #endif
	DeviceModel: systemInfo.model
};
/**
 * 全局配置
 * 只能配置 静态数据
 * `content-type` 默认为 application/json
 * header 中`content-type`设置特殊参数 或 配置其他会导致触发 跨域 问题，出现跨域会直接进入响应拦截器的catch函数中
 */
export const config = {
	// baseURL: process.env.NODE_ENV === 'development' ? 'http://localhost:21021/' : 'https://lehuo-getway.cnyanglao.com/',
	// https://lehuo-getway.cnyanglao.com/
	baseURL: 'https://lehuoclound-host2.cnyanglao.com/',
	allow: false,
	showToast: true,
	showLoading: true,
	// dataType: 'json',
	// responseType: 'text',
	header: {
		contentType: 'application/json',
		versioncode: 5,
		DeviceBrand: DeviceBrand,
		DeviceModel: DeviceModel
	}
};

/**
 * 全局 请求拦截器
 * 例如: 配置token
 *
 * `return config` 继续发送请求
 * `return false` 会停止发送请求，不会进入错误数据拦截，也不会进入请求对象中的catch函数中
 * `return Promise.reject('xxxxx')` 停止发送请求, 会错误数据拦截，也会进入catch函数中
 *
 * @param {Object} config 发送请求的配置数据
 */
globalInterceptor.request.use(
	(config) => {
		if (config.showLoading) {
			uni.showLoading({
				mask: true,
				title: '加载中'
			})
		}
		// config.baseURL=store.state.common.baseURL;
		config.header = Object.assign(config.header, {
			'Abp.TenantId': store.state.common.tenantId
		});
		var userInfo = getuserInfo();
		config.header.Authorization = userInfo.token;
		if(!store.state.normal.requestHeader){
			store.commit('setHeader', config.header);
		}
		return config;
	},
	(err) => {
		console.log(err)
		return false;
	}
);

// 支持添加多个请求、响应拦截器
// globalInterceptor.request.use(config => {
//     console.log('is global request interceptor 2');
//     return config;
// }, err => {
//     console.error('global request: ', err);
//     return false;
// });

/**
 * 全局 响应拦截器
 * 例如: 根据状态码选择性拦截、过滤转换数据
 *
 * `return res` 继续返回数据
 * `return false` 停止返回数据，不会进入错误数据拦截，也不会进入catch函数中
 * `return Promise.reject('xxxxx')` 返回错误信息, 会错误数据拦截，也会进入catch函数中
 *
 * @param {Object} res 请求返回的数据
 * @param {Object} config 发送请求的配置数据
 * @return {Object|Boolean|Promise<reject>}
 */
globalInterceptor.response.use(
	async (res, config) => {
			if (config.showLoading) {
				uni.hideLoading();
			}
			const statusCode = parseInt(res.statusCode);

			if (statusCode == 200) {
				if (config.allow) {
					return res.data;
				} else {
					return res.data.result;
				}

			} else if (statusCode == 401) {
				await login();
				// #ifdef H5
				return Promise.reject();
				// #endif
				// #ifdef MP-WEIXIN					
				//重新发送请求
				return Request().request(config);

				// #endif
			} else if (statusCode == 403) {
				//需要授权
				// #ifdef MP-WEIXIN
				var pages = getCurrentPages();
				var returnUrl = pages[pages.length - 1].route + '?';
				var options = pages[pages.length - 1].options;
				for (let [key, value] of Object.entries(options)) {
					console.log(key + ':' + value)
					returnUrl += key + '=' + value + '&';
				}
				returnUrl = returnUrl.substr(0, returnUrl.length - 1);
				returnUrl = encodeURIComponent(returnUrl);
				uni.redirectTo({
					url: '/pages/login/login?returnUrl=' + returnUrl
				});
				return Promise.reject(res.data, config);
				// #endif
			} else {
				if (config.showToast && res.data && res.data.error) {
					uni.showToast({
						title: res.data.error.message,
						icon: 'none',
						duration: 3000
					});
				}

				return Promise.reject(res.data, config);
			}

		},
		(err, config) => {
			if(err){
				setTimeout(()=>{
					uni.hideToast();
				}, 3000)
			}
			if (!err)
				err = 'error'
			return Promise.reject(err);
		}
);



//登陆
async function login() {
	await store.dispatch('user/loginAction');
}

// 获取token
function getuserInfo() {
	return {
		token: "Bearer " + store.state.user.token,
	};
}
